from google.colab import drive
drive.mount('/content/drive')

pip install protobuf==3.20.0

pip install opencv-python

pip install matplotlib

pip install mediapipe

pip install bm3d

pip install mediapipe opencv-python

import cv2
import mediapipe as mp
from mediapipe.tasks import python
from mediapipe.tasks.python import vision
import numpy as np
import math
import os
import matplotlib.pyplot as plt
from typing import Tuple, Union



def mp_image_creator(image_path):
    mp_image = mp.Image.create_from_file(image_path)
    return mp_image


def calculate_slope(point_1, point_2):
  x1, y1 = point_1[:2]
  x2, y2 = point_2[:2]

  if x1 - x2 != 0:
    slope = (y2 - y1) / (x2 - x1)
  return slope


def convert_to_rgb(image):
    rgb_image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
    return rgb_image




def detect_smile(image, detection_result):
    landmark_indices = [78, 306, 11 , 15, 1] # left corner, right corner, upper, lower, nose tip
    mouth_landmarks = []
    mouth_points = []
    # Extract mouth landmarks and mouth points and draw the landmarks
    if detection_result:
        for face_landmarks in detection_result.face_landmarks:
            for idx in landmark_indices:
                landmark = face_landmarks[idx]
                mouth_landmarks.append((landmark.x, landmark.y, landmark.z))
                # print(landmark.z)

                # Draw the landmarks on the image
                h, w, _ = image.shape
                x, y = int(landmark.x * w), int(landmark.y * h)
                mouth_points.append((x, y))
                # cv2.circle(image, (x, y), 7, (255, 0, 0), -1)  # Green circle for landmarks

            left_corner = mouth_landmarks[0]   # Left corner of the mouth
            right_corner = mouth_landmarks[1]  # Right corner of the mouth
            upper_corner = mouth_landmarks[2]  # location of the upper corner
            lower_corner = mouth_landmarks[3]  # location of the lower corner
            nose_tip = mouth_landmarks[4] # locatio of the nose tip
            # middle_mouth = ((left_corner[0] + right_corner[0]) / 2, (left_corner[1] + right_corner[1]) / 2)
            '''
            print(upper_corner)
            print(lower_corner)
            print(left_corner)
            print(right_corner)
            '''
            '''
            print(f"Upper Point: {upper_corner}")
            print(f"Lower Point: {lower_corner}")
            print(f"Left Point: {left_corner}")
            print(f"Right Point: {right_corner}")
            print(f"Nose Tip: {nose_tip}")
            '''

            # vertical_slope = calculate_slope(upper_corner, lower_corner)
            # horizontal_slope = calculate_slope(left_corner, right_corner)
            # print(vertical_slope * horizontal_slope)
            # distance_left_to_middle = math.dist(left_corner[:2], middle_mouth[:2])
            # distance_right_to_middle = math.dist(right_corner[:2], middle_mouth[:2])
            #distance_left_to_nose = math.dist(left_corner[:2], nose_tip[:2])
            #distance_right_to_nose = math.dist(right_corner[:2], nose_tip[:2])
            #distance_upper_to_middle = math.dist(upper_corner[:2], middle_mouth[:2])
            #distance_lower_to_middle = math.dist(lower_corner[:2], middle_mouth[:2])
            #distance_upper_to_nose = math.dist(upper_corner[:2], nose_tip[:2])
            #distance_lower_to_nose = math.dist(lower_corner[:2], nose_tip[:2])
            #normalized_upper = distance_upper_to_middle / distance_upper_to_nose
            #normalized_lower = distance_lower_to_middle / distance_lower_to_nose
            #normalized_left = distance_left_to_middle / distance_left_to_nose
            #normalized_right = distance_right_to_middle / distance_right_to_nose
            # print(normalized_left + normalized_right)
            horizontal_euqlidean_distance = math.dist(left_corner[:2], right_corner[:2])
            vertical_euqlidean_distance = math.dist(upper_corner[:2], lower_corner[:2])
            ratio = horizontal_euqlidean_distance / vertical_euqlidean_distance
            left_to_nose = math.dist(left_corner[:2], nose_tip[:2])
            right_to_nose = math.dist(right_corner[:2], nose_tip[:2])
            pose_ratio = left_to_nose / right_to_nose
            '''
            print(f"horizontal distance: {horizontal_euqlidean_distance}")
            print(f"vertical distance: {vertical_euqlidean_distance}")
            print(f"ratio: {ratio}")
            print(f"Left Nose Distance: {left_to_nose}")
            print(f"Right Nose Distance: {right_to_nose}")
            print(f"ratio2: {pose_ratio}")
            '''
            '''
            print(horizontal_euqlidean_distance)
            print(vertical_euqlidean_distance)
            print(ratio)
            '''
            #print(normalized_left + normalized_right)
            #print(normalized_upper + normalized_lower)
            #print((normalized_left + normalized_right) / (normalized_upper + normalized_lower))


            left_point = mouth_points[0]
            right_point = mouth_points[1]
            upper_point = mouth_points[2]
            lower_point = mouth_points[3]


        # print(left_corner[1] - lower_corner[1])


        # Smile logic
            if ((left_corner[1] < lower_corner[1]) and (right_corner[1] < lower_corner[1]) and (ratio > 2.8) and (abs(right_corner[1] - lower_corner[1]) > 0.0055) and (abs(left_corner[1] - lower_corner[1]) > 0.0055) and (left_corner[1] > upper_corner[1]) and (right_corner[1] > upper_corner[1])) or \
            ((left_corner[1] < lower_corner[1]) and (right_corner[1] < lower_corner[1]) and (ratio > 2.3)  and (left_corner[1] > upper_corner[1]) and (right_corner[1] > upper_corner[1]) and (vertical_euqlidean_distance > 0.15)) or \
            ((left_corner[1] > lower_corner[1]) and (right_corner[1] < lower_corner[1]) and (abs(right_corner[1] - lower_corner[1]) > 0.004)  and (ratio > 5.9) and (left_corner[1] > upper_corner[1]) and (right_corner[1] > upper_corner[1])) or \
            ((left_corner[1] < lower_corner[1]) and (right_corner[1] > lower_corner[1])  and (ratio > 5.9) and (abs(left_corner[1] - lower_corner[1]) > 0.004) and (left_corner[1] > upper_corner[1]) and (right_corner[1] > upper_corner[1])) or \
            ((left_corner[1] > lower_corner[1]) and (right_corner[1] < lower_corner[1]) and (abs(right_corner[1] - lower_corner[1]) <= 0.004)  and (abs(left_corner[1] - lower_corner[1]) > 0.005) and (ratio > 6.5) and (left_corner[1] > upper_corner[1]) and (right_corner[1] > upper_corner[1])) or \
            ((left_corner[1] < lower_corner[1]) and (right_corner[1] > lower_corner[1])  and (abs(left_corner[1] - lower_corner[1]) <= 0.004) and (abs(right_corner[1] - lower_corner[1]) > 0.005) and (ratio > 6.5) and (left_corner[1] > upper_corner[1]) and (right_corner[1] > upper_corner[1])) or\
            ((left_corner[1] > lower_corner[1]) and (right_corner[1] > lower_corner[1]) and (vertical_euqlidean_distance > 0.03) and (ratio > 6.5)) or \
            ((left_corner[1] < upper_corner[1]) and (right_corner[1] < upper_corner[1]) and (vertical_euqlidean_distance > 0.034) and (ratio > 7.0)) or \
            ((left_corner[1] < upper_corner[1]) and (right_corner[1] > upper_corner[1]) and (vertical_euqlidean_distance > 0.07) and (ratio > 3.0)) or \
            ((left_corner[1] > upper_corner[1]) and (right_corner[1] < upper_corner[1]) and (vertical_euqlidean_distance > 0.07) and (ratio > 3.0)) or \
            (((0.75 > pose_ratio) or  (pose_ratio > 1.5)) and (vertical_euqlidean_distance > 0.024) and (ratio > 6.0)) or \
            (((0.75 > pose_ratio) or  (pose_ratio > 1.5)) and (vertical_euqlidean_distance > 0.1) and (ratio > 2.8)):
                # Draw a rectangle around the mouth region
                # cv2.rectangle(image, (left_point[0], upper_point[1]), (right_point[0] , lower_point[1]), (0, 255, 0), 2)
                cv2.putText(image, "Smile Detected", (30, 60), cv2.FONT_HERSHEY_SIMPLEX, 2, (255, 0, 0), 3)
            else:
                cv2.putText(image, "No Smile", (30, 60), cv2.FONT_HERSHEY_SIMPLEX, 2, (0, 0, 255), 3)


    return image



def detect_faces(image, detection_result):
    """Draws bounding boxes on the input image and return it.

    Args:
        image: The input RGB image.
        detection_result: The list of all "Detection" entities to be visualized.

    Returns:
        Image with bounding boxes.
    """
    annotated_image = image.copy()
    height, width, _ = image.shape

    for detection in detection_result.detections:
        # Draw bounding box
        bbox = detection.bounding_box
        start_point = (int(bbox.origin_x), int(bbox.origin_y))
        end_point = (int(bbox.origin_x + bbox.width), int(bbox.origin_y + bbox.height))
        cv2.rectangle(annotated_image, start_point, end_point, (0, 255, 255), 2)

    return annotated_image







def second_pipeline(np_image):

    copy_image = np_image.copy()


    l_image = analyze_luminance(np_image)


    # print(Edge_analyze_2(l_image))
    # print(Edge_analyze(l_image))


    if Edge_analyze(l_image) < 1.7:
      l_image = denoise_sharpen(l_image)
      # print(Edge_analyze(l_image))

      # l_image = clahe(l_image)

      # print(calculate_noise_level(l_image))
      if 1.17 < Edge_analyze(l_image) < 1.3:
      # l_image = cv2.fastNlMeansDenoisingColored(l_image, None, 20, 7, 21)
        kernel_1 = np.array([[0, -0.1, 0], [-0.1, 1.7, -0.1], [0, -0.1, 0]])
        l_image = cv2.filter2D(l_image, -1, kernel_1)
        # l_image = cv2.fastNlMeansDenoisingColored(l_image, None, 10, 7, 21)
        # print(Edge_analyze(l_image))


      elif 1.3 < Edge_analyze(l_image) < 1.4:
        kernel_2 = np.array([[0, -0.1, 0], [-0.1, 1.4, -0.1], [0, -0.1, 0]])
        l_image = cv2.filter2D(l_image, -1, kernel_2)
      #  print(Edge_analyze(l_image))



      elif 1.4 < Edge_analyze(l_image) < 1.5:
        kernel_3 = np.array([[0, -0.1, 0], [-0.1, 1.35, -0.1], [0, -0.1, 0]])
        l_image = cv2.filter2D(l_image, -1, kernel_3)
       # print(Edge_analyze(l_image))


      elif 1.5 < Edge_analyze(l_image) < 1.6:
        kernel_4 = np.array([[0, -0.1, 0], [-0.1, 1.3, -0.1], [0, -0.1, 0]])
        l_image = cv2.filter2D(l_image, -1, kernel_4)
       #  print(Edge_analyze(l_image))

      elif 1.6 < Edge_analyze(l_image) < 1.7:
        kernel_5 = np.array([[0, -0.1, 0], [-0.1, 1.25, -0.1], [0, -0.1, 0]])
        l_image = cv2.filter2D(l_image, -1, kernel_5)
        # print(Edge_analyze(l_image))

      elif 1.7 < Edge_analyze(l_image) < 2.1:
        kernel_6 = np.array([[0, -0.1, 0], [-0.1, 1.1, -0.1], [0, -0.1, 0]])
        l_image = cv2.filter2D(l_image, -1, kernel_6)
        # print(Edge_analyze(l_image))

    '''
    # denoised_image = NLM_denoising(l_image)
    if 70.66 > calculate_noise_level(l_image) > 70.65:
      kernel = np.array([[0, -0.2, 0], [-0.2, 2, -0.2], [0, -0.2, 0]])
      l_image = cv2.filter2D(l_image, -1, kernel)
      # l_image = cv2.fastNlMeansDenoisingColored(l_image, None, 20, 7, 21)
      # l_image = clahe(l_image)
      print(Edge_analyze(l_image))
      print(calculate_noise_level(l_image))
    '''




    '''
    if 1.5 < Edge_analyze(l_image) < 1.6:
      kernel = np.array([[0, -0.1, 0], [-0.1, 1.3, -0.1], [0, -0.1, 0]])
      l_image = cv2.filter2D(l_image, -1, kernel)
      print(Edge_analyze(l_image))
    '''
    '''
    if Edge_analyze(l_image) > 1.5 and calculate_noise_level(l_image) > 70:
      l_image = cv2.fastNlMeansDenoisingColored(l_image, None, 15, 7, 21)
      print(Edge_analyze(l_image))
      print(calculate_noise_level(l_image))
    '''


    mp_image = mp.Image(image_format=mp.ImageFormat.SRGB, data=l_image)

    rgb_image = convert_to_rgb(copy_image)


    # print(type(mp_image))

    # Create a FaceDetector object.
    base_options = python.BaseOptions(model_asset_path='/content/drive/MyDrive/blaze_face_short_range.tflite')
    options = vision.FaceDetectorOptions(base_options=base_options,
                                     min_detection_confidence = 0.52
                                    )
    face_detector = vision.FaceDetector.create_from_options(options)

    face_detection_result = face_detector.detect(mp_image)

    # print(face_detection_result)

    '''
    if not face_detection_result.detections:
      kernel_7 = np.array([[0, -1, 0], [-1, 1.5, -1], [0, -1, 0]])
      l_image = cv2.filter2D(l_image, -1, kernel_7)
      print(Edge_analyze(l_image))
      mp_image = mp.Image(image_format=mp.ImageFormat.SRGB, data=l_image)
      face_detection_result = face_detector.detect(mp_image)
      print(face_detection_result)

    '''

    if not face_detection_result.detections:

      count = 1;
      while(not face_detection_result.detections and count < 30):
        l_image = cv2.fastNlMeansDenoisingColored(l_image, None, count, 7, 21)
        # print(Edge_analyze(l_image))
        mp_image = mp.Image(image_format=mp.ImageFormat.SRGB, data=l_image)
        face_detection_result = face_detector.detect(mp_image)
        # print(face_detection_result)
        count += 1
      # print(count)

      count = 1.5
      while(not face_detection_result.detections and count < 20):
        kernel_new = np.array([[0, -0.1, 0], [-0.1, count, -0.1], [0, -0.1, 0]])
        l_image = cv2.filter2D(l_image, -1, kernel_new)
        # print(Edge_analyze(l_image))
        mp_image = mp.Image(image_format=mp.ImageFormat.SRGB, data=l_image)
        face_detection_result = face_detector.detect(mp_image)
        # print(face_detection_result)
        count += 0.5
      # print(face_detection_result)
      # print(count)






    # Detect Faces
    image_with_faces = detect_faces(rgb_image, face_detection_result)

    # Create a FaceLandmarker object.
    base_options = python.BaseOptions(model_asset_path='/content/drive/MyDrive/face_landmarker.task')
    options = vision.FaceLandmarkerOptions(base_options=base_options,
                                       output_face_blendshapes=True,
                                       output_facial_transformation_matrixes=True,
                                       num_faces=5,
                                       min_face_detection_confidence = 0.5,
                                       min_face_presence_confidence = 0.5
                                      )
    Landmark_detector = vision.FaceLandmarker.create_from_options(options)

    # Try to detect smiles
    Landmark_detection_result = Landmark_detector.detect(mp_image)

    # print(Landmark_detection_result)

    final_image = detect_smile(image_with_faces, Landmark_detection_result)



    return final_image








'''
image = mp.Image.create_from_file("Desktop/Test images/me11.png")
# image_path = "Desktop/me5.jpg"
# print(image.shape)
image_copy = np.copy(image.numpy_view())
# print(len(list))
output_image = task_pipeline(image_copy, image)
plt.figure(figsize = (12, 6))
plt.imshow(output_image[..., ::-1])
'''

if __name__ == "__main__":

    desktop_folder = os.path.join("/content", "drive", "MyDrive", "Test images")
    test2_folder = os.path.join(desktop_folder, "Test 2")

    #Get a list of all the image files in the desktop folder
    image_paths = []

    for f in os.listdir(test2_folder):
        if f.endswith(".jpg") or f.endswith(".png"):
            file_path = os.path.join(test2_folder, f)
            image_paths.append(file_path)



    for image_path in image_paths:
        image = first_pipeline(image_path)
        plt.figure(figsize=(12, 5))
        plt.imshow(image[..., ::-1])
        plt.axis('off')
        plt.show()

desktop_folder = os.path.join("/content", "drive", "MyDrive", "Test images")
test2_folder = os.path.join(desktop_folder, "Test 2")

#Get a list of all the image files in the directory
image_paths = []


for f in os.listdir(test2_folder):
    if f.endswith(".jpg") or f.endswith(".png"):
        file_path = os.path.join(test2_folder, f)
        image_paths.append(file_path)



for image_path in image_paths:
    np_image = cv2.imread(image_path)
    if np_image.shape[0] < 1000 and np_image.shape[1] < 1000:
      np_image = cv2.resize(np_image, (1200, 1200), interpolation = cv2.INTER_LINEAR)
    output_image = second_pipeline(np_image)
    plt.figure(figsize=(12, 5))
    plt.imshow(output_image)
    plt.axis('off')
    plt.show()

plt.tight_layout()
plt.show()